package org.example.lib.utils;

import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;
import java.lang.reflect.Parameter;
import java.util.ArrayList;
import java.util.List;

public class ClassHelper {

    public static List<Class<?>> getDependence(Class<?> clazz){
        List<Class<?>> dependencies = new ArrayList<>();
        if (clazz.getDeclaredConstructors().length != 1) {
            return dependencies;
        }

        Parameter[] parameters = clazz.getDeclaredConstructors()[0].getParameters();
        for (Parameter parameter : parameters) {
            dependencies.add(parameter.getType());
        }

        return dependencies;
    }

    public static boolean isInstantiable(Class<?> clazz) {
        if (clazz == null) {
            return false;
        }

        // 排除基本类型、数组、void
        if (clazz.isPrimitive() || clazz.isArray() || clazz == void.class) {
            return false;
        }

        // 排除接口、枚举、注解、抽象类
        int modifiers = clazz.getModifiers();
        if (Modifier.isInterface(modifiers) ||
            Modifier.isAbstract(modifiers) ||
            clazz.isEnum() ||
            clazz.isAnnotation()) {
            return false;
        }

        // 检查是否存在可访问的构造器
        try {
            // 尝试获取无参构造器
            Constructor<?> constructor = clazz.getDeclaredConstructor();

            // 若构造器为私有，检查是否可通过setAccessible访问
            if (!constructor.canAccess(null)) {
                constructor.setAccessible(true); // 尝试设置可访问
                boolean accessible = constructor.canAccess(null);
                constructor.setAccessible(false); // 恢复原始状态
                return accessible;
            }

            return true;
        } catch (NoSuchMethodException e) {
            // 无参构造器不存在，检查是否存在其他构造器
            Constructor<?>[] constructors = clazz.getDeclaredConstructors();
            if (constructors.length == 0) {
                return false; // 理论上不会发生，任何类都有至少一个构造器
            }

            // 检查是否存在可访问的构造器
            for (Constructor<?> constructor : constructors) {
                if (constructor.canAccess(null)) {
                    return true;
                }
            }

            // 所有构造器均为私有，尝试设置可访问
            for (Constructor<?> constructor : constructors) {
                try {
                    constructor.setAccessible(true);
                    boolean accessible = constructor.canAccess(null);
                    constructor.setAccessible(false);
                    if (accessible) {
                        return true;
                    }
                } catch (SecurityException ex) {
                    // 忽略，继续检查其他构造器
                }
            }

            return false;
        }
    }
}
